﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using System.Windows;
using CapaPresentacion.Commands;
using Entidades;
using CapaLogica;
using CapaPresentacion.Vistas;
using CapaPresentacion.Utilidades;
using Microsoft.Win32;
using System.Windows.Media.Imaging;
using System.Transactions;
using System.Collections.ObjectModel;
using System.IO;
using System.Globalization;

namespace CapaPresentacion.Controles
{

    internal delegate void CargarFamiliar(Familiar fam, string tipoFamiliar);

    class NuevoAlumnoViewModel
    {
        public event ReiniciarCU ReiniciarCU;

        private RelayCommand saveCommand;
        private RelayCommand newCommand;
        private RelayCommand openCommand;
        private RelayCommand loadImageCommand;
        private RelayCommand agregarAlergiaCommand;
        private RelayCommand quitarAlergiaCommand;
        private RelayCommand agregarEnfermedadCommand;
        private RelayCommand quitarEnfermedadCommand;
        private RelayCommand agregarHermanoCommand;
        private RelayCommand quitarHermanoCommand;
        private RelayCommand cargarMadreCommand;
        private RelayCommand cargarPadreCommand;
        private RelayCommand cargarUrgencia1Command;
        private RelayCommand cargarUrgencia2Command;
        private RelayCommand cargarAutorizado1Command;
        private RelayCommand cargarAutorizado2Command;

        private NuevoAlumno view;

        private Alumno alumno;
        private Alumno alumnoSinModificaciones;

        private System.Drawing.Image imagenAlumno; 

        public Alumno Alumno
        {
            get { return alumno; }
            set { alumno = value; }
        }   
        

        public ICommand SaveCommand
        {
            get
            {
                return saveCommand;
            }
        }

        public ICommand NewCommand
        {
            get
            {
                return newCommand;
            }
        }

        public ICommand OpenCommand
        {
            get
            {
                return openCommand;
            }
        }

        public ICommand LoadImageCommand
        {
            get
            {
                return loadImageCommand;
            }
        }

        public ICommand AgregarAlergiaCommand
        {
            get
            {
                return agregarAlergiaCommand;
            }
        }

        public ICommand QuitarAlergiaCommand
        {
            get
            {
                return quitarAlergiaCommand;
            }
        }

        public ICommand AgregarEnfermedadCommand
        {
            get
            {
                return agregarEnfermedadCommand;
            }
        }

        public ICommand QuitarEnfermedadCommand
        {
            get
            {
                return quitarEnfermedadCommand;
            }
        }

        public ICommand AgregarHermanoCommand
        {
            get
            {
                return agregarHermanoCommand;
            }
        }

        public ICommand QuitarHermanoCommand
        {
            get
            {
                return quitarHermanoCommand;
            }
        }


        public ICommand CargarMadreCommand
        {
            get
            {
                return cargarMadreCommand;
            }
        }

        public ICommand CargarPadreCommand
        {
            get
            {
                return cargarPadreCommand;
            }
        }

        public ICommand CargarUrgencia1Command
        {
            get
            {
                return cargarUrgencia1Command;
            }
        }

        public ICommand CargarUrgencia2Command
        {
            get
            {
                return cargarUrgencia2Command;
            }
        }

        public ICommand CargarAutorizado1Command
        {
            get
            {
                return cargarAutorizado1Command;
            }
        }

        public ICommand CargarAutorizado2Command
        {
            get
            {
                return cargarAutorizado2Command;
            }
        }
               

        public List<ViewEntity> ListaParentescos { get; set; }
        public List<ViewEntity> ListaTiposSanguineos { get; set; }
        public List<ViewEntity> ListaSituacionPadres { get; set; }
        public List<ViewEntity> ListaZonaVivienda { get; set; }
        public List<ViewEntity> ListaTipoParto { get; set; }
        public List<ViewEntity> ListaTipoLactancia { get; set; }
        public List<ViewEntity> ListaTipoDestete { get; set; }
        public List<ViewEntity> ListaTipoAbandonoMamadera { get; set; }
        public List<ViewEntity> ListaTipoAbandonoChupete { get; set; }
        public List<ViewEntity> ListaTipoDespertar { get; set; }
        public List<ViewEntity> ListaTipoPronunciacion { get; set; }
        public List<ViewEntity> ListaTipoJuego { get; set; }
        public List<ViewEntity> ListaSiSeDespierta { get; set; }


        public NuevoAlumnoViewModel()
        {


        }

        public void Inicializar(NuevoAlumno vista)
        {

            if (new FamiliarAlumnoLogica().ExistenFamiliares())
            {

                alumno = new Alumno();
                alumno.LegajoAlumno = Guid.NewGuid();
                alumno.Eliminado = false;


                alumno.PadreTutor = new Familiar();
                alumno.MadreTutora = new Familiar();

                alumno.Urgencia1 = new Familiar();
                alumno.Urgencia2 = new Familiar();

                alumno.Autorizado1 = new Familiar();
                alumno.Autorizado2 = new Familiar();

                alumno.AlumnoSalud = new AlumnoSalud();
                alumno.AlumnoAlimentacion = new AlumnoAlimentacion();
                alumno.AlumnoHabitos = new AlumnoHabitos();
                alumno.AlumnoFamiliares = new TrackableCollection<AlumnoFamiliar>();
                alumno.AlumnoInstitucion = new AlumnoInstitucion();
                alumno.AlumnoNacimiento = new AlumnoNacimiento();
                alumno.AlumnoVidaFamiliar = new AlumnoVidaFamiliar();
                alumno.AlumnoVidaSocial = new AlumnoVidaSocial();

                this.view = vista;

                this.saveCommand = new RelayCommand(GuardarAlumno);
                this.newCommand = new RelayCommand(NuevoAlumno);
                this.openCommand = new RelayCommand(AbrirAlumno);
                this.loadImageCommand = new RelayCommand(CargarFoto);
                this.agregarAlergiaCommand = new RelayCommand(AgregarAlergia);
                this.quitarAlergiaCommand = new RelayCommand(QuitarAlergia);
                this.agregarEnfermedadCommand = new RelayCommand(AgregarEnfermedad);
                this.quitarEnfermedadCommand = new RelayCommand(QuitarEnfermedad);
                this.agregarHermanoCommand = new RelayCommand(AgregarHermano);
                this.quitarHermanoCommand = new RelayCommand(QuitarHermano);
                this.cargarMadreCommand = new RelayCommand(CargarMadre);
                this.cargarPadreCommand = new RelayCommand(CargarPadre);
                this.cargarUrgencia1Command = new RelayCommand(CargarUrgencia1);
                this.cargarUrgencia2Command = new RelayCommand(CargarUrgencia2);
                this.cargarAutorizado1Command = new RelayCommand(CargarAutorizado1);
                this.cargarAutorizado2Command = new RelayCommand(CargarAutorizado2);

                this.CargarListas();
            }
            else
            {

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "                        No se encontraron datos de familiares. \n Para cargar un alumno, primero cargue los datos de (al menos) un familiar");
                nueva.ShowDialog();
                this.ReiniciarCU(CasosDeUso.NuevoFamiliarAlumno);

            }
        }

        public  void Inicializar(NuevoAlumno vista, Alumno entidad)
        {
           
                alumno = entidad;
                alumnoSinModificaciones = (Alumno)entidad.Clone();
                this.view = vista;

                if (alumno.FotoAlumno != null)
                {
                    BitmapImage imagen = ImageUtil.Bytes2BitmapImage(alumno.FotoAlumno);

                    this.view.imgFotoAlumno.Stretch = System.Windows.Media.Stretch.Fill;
                    this.view.imgFotoAlumno.Source = imagen;
                    this.view.imgFotoAlumno.ToolTip = "Foto del Alumno";
                }


                // Obtengo los datos de los padres, familiares autorizados a retirar al niño y a ser contactados en caso de urgencia

                alumno.PadreTutor = new Familiar();
                alumno.MadreTutora = new Familiar();

                alumno.Urgencia1 = new Familiar();
                alumno.Urgencia2 = new Familiar();

                alumno.Autorizado1 = new Familiar();
                alumno.Autorizado2 = new Familiar();

                var existeMadre = (from v in alumno.AlumnoFamiliares
                                   where v.IdParentesco == new ParentescoLogica().ObtenerIdMadreTutora()
                                   select v.LegajoFamiliar).Any();

                if (existeMadre)
                {
                    var idMadre = (from v in alumno.AlumnoFamiliares
                                   where v.IdParentesco == new ParentescoLogica().ObtenerIdMadreTutora()
                                   select v.LegajoFamiliar).First();

                    alumno.MadreTutora = new FamiliarAlumnoLogica().ObtenerEntidad(idMadre);

                    this.view.pnlDatosRecuperadosMadre.Visibility = Visibility.Visible;
                }


                var existePadre = (from v in alumno.AlumnoFamiliares
                                   where v.IdParentesco == new ParentescoLogica().ObtenerIdPadreTutor()
                                   select v.LegajoFamiliar).Any();

                if (existePadre)
                {
                    var idPadre = (from v in alumno.AlumnoFamiliares
                                   where v.IdParentesco == new ParentescoLogica().ObtenerIdPadreTutor()
                                   select v.LegajoFamiliar).First();

                    alumno.PadreTutor = new FamiliarAlumnoLogica().ObtenerEntidad(idPadre);

                    this.view.pnlDatosRecuperadosPadre.Visibility = Visibility.Visible;
                }


                var cantidadUrgencia = (from v in alumno.AlumnoFamiliares
                                        where v.Urgencia == true
                                        select v.LegajoFamiliar).ToList();

                if (cantidadUrgencia.Count > 0)
                {
                    if (cantidadUrgencia.Count == 1)
                    {
                        this.alumno.Urgencia1 = new FamiliarAlumnoLogica().ObtenerEntidad(cantidadUrgencia[0]);
                        this.view.pnlDatosRecuperadosUrgencia1.Visibility = Visibility.Visible;
                    }


                    if (cantidadUrgencia.Count == 2)
                    {
                        this.alumno.Urgencia1 = new FamiliarAlumnoLogica().ObtenerEntidad(cantidadUrgencia[0]);
                        this.alumno.Urgencia2 = new FamiliarAlumnoLogica().ObtenerEntidad(cantidadUrgencia[1]);

                        this.view.pnlDatosRecuperadosUrgencia1.Visibility = Visibility.Visible;
                        this.view.pnlDatosRecuperadosUrgencia2.Visibility = Visibility.Visible;
                    }


                }
            
                this.saveCommand = new RelayCommand(GuardarAlumno);
                this.newCommand = new RelayCommand(NuevoAlumno);
                this.openCommand = new RelayCommand(AbrirAlumno);
                this.loadImageCommand = new RelayCommand(CargarFoto);
                this.agregarAlergiaCommand = new RelayCommand(AgregarAlergia);
                this.quitarAlergiaCommand = new RelayCommand(QuitarAlergia);
                this.agregarEnfermedadCommand = new RelayCommand(AgregarEnfermedad);
                this.quitarEnfermedadCommand = new RelayCommand(QuitarEnfermedad);
                this.agregarHermanoCommand = new RelayCommand(AgregarHermano);
                this.quitarHermanoCommand = new RelayCommand(QuitarHermano);
                this.cargarMadreCommand = new RelayCommand(CargarMadre);
                this.cargarPadreCommand = new RelayCommand(CargarPadre);
                this.cargarUrgencia1Command = new RelayCommand(CargarUrgencia1);
                this.cargarUrgencia2Command = new RelayCommand(CargarUrgencia2);
                this.cargarAutorizado1Command = new RelayCommand(CargarAutorizado1);
                this.cargarAutorizado2Command = new RelayCommand(CargarAutorizado2);

                this.CargarListas();
            
            
        }

        private void NuevoAlumno(Object parameter)
        {
            if (MessageBox.Show("¿Está seguro que desea cargar los datos de un nuevo alumno?", "Confirme su Decisión", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
            {
                this.ReiniciarCU(CasosDeUso.NuevoAlumno);
            }
        }

        private void AbrirAlumno(Object parameter)
        {
            if (MessageBox.Show("¿Está seguro que desea editar los datos de un alumno existente?", "Confirme su Decisión", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
            {
                this.ReiniciarCU(CasosDeUso.BuscarAlumno);
            }
        }

        private void CargarFoto(Object parameter)
        {
            OpenFileDialog buscador = new OpenFileDialog();
            buscador.Filter = "Archivos de imágen (.jpg)|*.jpg|Archivos Portable Network Graphics (*.png)|*.png|Archivos Bit Mapped Picture(*.bmp)|*.bmp|Iconos(*.ico)|*.ico";
            buscador.FilterIndex = 1;
            buscador.Multiselect = false;

            bool? ClickeadoOK = buscador.ShowDialog();
            if (ClickeadoOK == true)
            {
                this.imagenAlumno = new System.Drawing.Bitmap(buscador.FileName);

                this.view.imgFotoAlumno.Source = new BitmapImage(new Uri(buscador.FileName));
                this.view.imgFotoAlumno.ToolTip = "Foto del Alumno";
            } 
            
        }

        private void GuardarAlumno(Object parameter)
        {
            if (MessageBox.Show("¿Está seguro que desea guardar los datos?", "Confirme su Decisión", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
            {

                if (Validaciones())
                {
                   
                    try
                    {

                        this.PrimeraLetraNombresMayuscula();

                        if (imagenAlumno != null)
                        {
                            this.alumno.FotoAlumno = ImageUtil.Image2Bytes(imagenAlumno);
                        }                            

                        this.ValidacionesDeConsistencia();

                        if(!new AlumnoLogica().ExisteEntidad(this.alumno.LegajoAlumno)) // Nuevo Alumno
                        {
                          
                            new AlumnoLogica().Agregar(alumno);

                            VentanaAviso nueva = new VentanaAviso(false, "Finalización Exitosa", "El alumno ha sido creado correctamente");
                            nueva.ShowDialog();
                        }
                        else                        // Edición Alumno
                        {

                            new AlumnoLogica().Modificar(alumno);

                            VentanaAviso nueva = new VentanaAviso(false, "Finalización Exitosa", "El alumno ha sido modificado correctamente");
                            nueva.ShowDialog();

                        }
                            
                    }
                    catch (Exception)
                    {

                        VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "  Ha ocurrido un error y el alumno no se ha guardado");
                        nueva.ShowDialog();

                    }                   
                }
                
            }
        }


        internal void PrimeraLetraNombresMayuscula()
        {

            this.alumno.ApellidoAlumno = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.ApellidoAlumno);
            this.alumno.NombreAlumno = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.NombreAlumno);
            this.alumno.LocalidadAlumno = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.LocalidadAlumno);

            if (this.alumno.LugarNacimiento != null)
                this.alumno.LugarNacimiento = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.LugarNacimiento);

            if (this.alumno.ApodoAlumno != null)
                this.alumno.ApodoAlumno = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.ApodoAlumno);

            if (this.alumno.AlumnoSalud.Pediatra != null)
                this.alumno.AlumnoSalud.Pediatra = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.AlumnoSalud.Pediatra);

            if (this.alumno.AlumnoSalud.ObraSocial != null)
                this.alumno.AlumnoSalud.ObraSocial = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.AlumnoSalud.ObraSocial);

            if (this.alumno.AlumnoVidaFamiliar.ReligionFamilia != null)
                this.alumno.AlumnoVidaFamiliar.ReligionFamilia = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(this.alumno.AlumnoVidaFamiliar.ReligionFamilia);

        }


        private void AgregarAlergia(Object parameter)
        {
            if (!String.IsNullOrWhiteSpace(this.view.txtNombreAlergia.Text))
            {
                bool existe = false;
                foreach (var v in alumno.AlergiasAlumno)
                {
                    if (v.NombreAlergia.ToLower() == this.view.txtNombreAlergia.Text.Trim().ToLower())
                        existe = true;

                }
                if (!existe)
                {
                    AlergiaAlumno nueva = new AlergiaAlumno();
                    nueva.LegajoAlumno = alumno.LegajoAlumno;
                    nueva.NombreAlergia = this.view.txtNombreAlergia.Text.Trim();

                    alumno.AlergiasAlumno.Add(nueva);
                    this.view.txtNombreAlergia.Text = String.Empty;
                }


            }
        }

        private void QuitarAlergia(Object parameter)
        {
            if (this.view.listaDatosAlergias.SelectedIndex != -1)
                alumno.AlergiasAlumno.RemoveAt(this.view.listaDatosAlergias.SelectedIndex);

        }




        private void AgregarEnfermedad(Object parameter)
        {
            if (!String.IsNullOrWhiteSpace(this.view.txtNombreEnfermedad.Text))
            {
                bool existe = false;
                foreach (var v in alumno.EnfermedadesAlumno)
                {
                    if (v.NombreEnfermedad.ToLower() == this.view.txtNombreEnfermedad.Text.Trim().ToLower())
                        existe = true;

                }
                if (!existe)
                {
                    EnfermedadAlumno nueva = new EnfermedadAlumno();
                    nueva.LegajoAlumno = alumno.LegajoAlumno;
                    nueva.NombreEnfermedad = this.view.txtNombreEnfermedad.Text.Trim();

                    alumno.EnfermedadesAlumno.Add(nueva);
                    this.view.txtNombreEnfermedad.Text = String.Empty;
                }


            }
        }

        private void QuitarEnfermedad(Object parameter)
        {
            if (this.view.listaDatosEnfermedades.SelectedIndex != -1)
                alumno.EnfermedadesAlumno.RemoveAt(this.view.listaDatosEnfermedades.SelectedIndex);

        }



        private void AgregarHermano(Object parameter)
        {
            if (!String.IsNullOrWhiteSpace(this.view.txtNombreHermano.Text) && !String.IsNullOrWhiteSpace(this.view.txtEdadHermano.Text ))
            {
                bool existe = false;
                foreach (var v in alumno.HermanosAlumno)
                {
                    if (v.NombreHermano.ToLower() == this.view.txtNombreHermano.Text.Trim().ToLower() && v.EdadHermano == System.Convert.ToInt32(this.view.txtEdadHermano.Text))
                        existe = true;

                }
                if (!existe)
                {
                    HermanoAlumno nuevo = new HermanoAlumno();
                    nuevo.LegajoAlumno = alumno.LegajoAlumno;
                    nuevo.NombreHermano = this.view.txtNombreHermano.Text.Trim();
                    nuevo.EdadHermano = System.Convert.ToInt32(this.view.txtEdadHermano.Text);
                    nuevo.NombreAMostrar = this.view.txtNombreHermano.Text.Trim() + "  /  " + this.view.txtEdadHermano.Text + " años";



                    alumno.HermanosAlumno.Add(nuevo);
                    this.view.txtNombreHermano.Text = String.Empty;
                    this.view.txtEdadHermano.Text = String.Empty;
                }


            }
        }

        private void QuitarHermano(Object parameter)
        {
            if (this.view.listaHermanos.SelectedIndex != -1)
                alumno.HermanosAlumno.RemoveAt(this.view.listaHermanos.SelectedIndex);

        }









        private void CargarMadre(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Madre o Tutora", "MadreTutora", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();
           
        }

        private void CargarPadre(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Padre o Tutor", "PadreTutor", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();
           

        }

        private void CargarUrgencia1(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Familiar a contactar en caso de Urgencia", "Urgencia1", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();

        }

        private void CargarUrgencia2(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Familiar a contactar en caso de Urgencia", "Urgencia2", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();

        }

        private void CargarAutorizado1(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Familiar autorizado para retirar al niño", "Autorizado1", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();

        }

        private void CargarAutorizado2(Object parameter)
        {
            VentanaBusquedaPadresTutores nueva = new VentanaBusquedaPadresTutores();
            VentanaBusquedaPadresTutoresViewModel vbptVM = new VentanaBusquedaPadresTutoresViewModel(nueva, "Búsqueda de Familiar autorizado para retirar al niño", "Autorizado2", this.alumno);

            nueva.DataContext = vbptVM;
            vbptVM.CargarFamiliar += this.OnCargarFamiliar;

            nueva.ShowDialog();

        }

        private void OnCargarFamiliar(Familiar fam, string tipo)
        {
            switch(tipo)
            {
                case "MadreTutora":

                    if (alumno.MadreTutora.LegajoFamiliar == Guid.Empty)
                    {
                        alumno.MadreTutora = fam;
                        AlumnoFamiliar nuevo = new AlumnoFamiliar();
                        nuevo.LegajoAlumno = alumno.LegajoAlumno;
                        nuevo.LegajoFamiliar = alumno.MadreTutora.LegajoFamiliar;
                        nuevo.IdParentesco = new ParentescoLogica().ObtenerIdMadreTutora();
                        nuevo.ChangeTracker.State = ObjectState.Added;
                        alumno.AlumnoFamiliares.Add(nuevo);

                        this.view.pnlDatosRecuperadosMadre.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        if (alumno.MadreTutora.LegajoFamiliar != fam.LegajoFamiliar)
                        {                           
                            int i = 0;
                            Guid idMadre = new ParentescoLogica().ObtenerIdMadreTutora();
                            foreach (var item in alumno.AlumnoFamiliares)
                            {
                                if (item.IdParentesco != idMadre)
                                    i++;
                                else
                                    break;
                            }
                            this.alumno.AlumnoFamiliares.RemoveAt(i);

                            alumno.MadreTutora = fam;
                            AlumnoFamiliar nuevo = new AlumnoFamiliar();
                            nuevo.LegajoAlumno = alumno.LegajoAlumno;
                            nuevo.LegajoFamiliar = alumno.MadreTutora.LegajoFamiliar;
                            nuevo.IdParentesco = idMadre;
                            nuevo.ChangeTracker.State = ObjectState.Added;
                            alumno.AlumnoFamiliares.Add(nuevo);
                            
                        }

                    }
                        break;

                case "PadreTutor":                    

                    if (alumno.PadreTutor.LegajoFamiliar == Guid.Empty)
                    {
                        alumno.PadreTutor = fam;
                        AlumnoFamiliar nuevo = new AlumnoFamiliar();
                        nuevo.LegajoAlumno = alumno.LegajoAlumno;
                        nuevo.LegajoFamiliar = alumno.PadreTutor.LegajoFamiliar;
                        nuevo.IdParentesco = new ParentescoLogica().ObtenerIdPadreTutor();
                        nuevo.ChangeTracker.State = ObjectState.Added;
                        alumno.AlumnoFamiliares.Add(nuevo);

                        this.view.pnlDatosRecuperadosPadre.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        if (alumno.PadreTutor.LegajoFamiliar != fam.LegajoFamiliar)
                        {
                            int i = 0;
                            Guid idPadre = new ParentescoLogica().ObtenerIdPadreTutor();
                            foreach (var item in alumno.AlumnoFamiliares)
                            {
                                if (item.IdParentesco != idPadre)
                                    i++;
                                else
                                    break;
                            }
                            this.alumno.AlumnoFamiliares.RemoveAt(i);

                            alumno.PadreTutor = fam;
                            AlumnoFamiliar nuevo = new AlumnoFamiliar();
                            nuevo.LegajoAlumno = alumno.LegajoAlumno;
                            nuevo.LegajoFamiliar = alumno.PadreTutor.LegajoFamiliar;
                            nuevo.IdParentesco = idPadre;
                            nuevo.ChangeTracker.State = ObjectState.Added;
                            alumno.AlumnoFamiliares.Add(nuevo);                                
                            
                        }
                    }
                    break;


                case "Urgencia1":

                    if (alumno.Urgencia1.LegajoFamiliar == Guid.Empty)
                    {
                        alumno.Urgencia1 = fam;
                        AlumnoFamiliar nuevo = new AlumnoFamiliar();
                        nuevo.LegajoAlumno = alumno.LegajoAlumno;
                        nuevo.LegajoFamiliar = alumno.Urgencia1.LegajoFamiliar;
                        nuevo.IdParentesco = new Guid(alumno.Urgencia1.IdParentesco);
                        nuevo.Urgencia = true;
                        nuevo.ChangeTracker.State = ObjectState.Added;
                        alumno.AlumnoFamiliares.Add(nuevo);

                        this.view.pnlDatosRecuperadosUrgencia1.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        if (alumno.Urgencia1.LegajoFamiliar != fam.LegajoFamiliar)
                        {
                            int i = 0;
                            Guid idFamiliar = fam.LegajoFamiliar;
                            foreach (var item in alumno.AlumnoFamiliares)
                            {
                                if (item.LegajoFamiliar != alumno.Urgencia1.LegajoFamiliar)
                                    i++;
                                else
                                    break;
                            }
                            this.alumno.AlumnoFamiliares.RemoveAt(i);

                            alumno.Urgencia1 = fam;
                            AlumnoFamiliar nuevo = new AlumnoFamiliar();
                            nuevo.LegajoAlumno = alumno.LegajoAlumno;
                            nuevo.LegajoFamiliar = alumno.Urgencia1.LegajoFamiliar;
                            nuevo.IdParentesco = new Guid(alumno.Urgencia1.IdParentesco);
                            nuevo.Urgencia = true;
                            nuevo.ChangeTracker.State = ObjectState.Added;
                            alumno.AlumnoFamiliares.Add(nuevo);

                        }
                    }
                    break;

                case "Urgencia2":

                    if (alumno.Urgencia2.LegajoFamiliar == Guid.Empty)
                    {
                        alumno.Urgencia2 = fam;
                        AlumnoFamiliar nuevo = new AlumnoFamiliar();
                        nuevo.LegajoAlumno = alumno.LegajoAlumno;
                        nuevo.LegajoFamiliar = alumno.Urgencia2.LegajoFamiliar;
                        nuevo.IdParentesco = new Guid(alumno.Urgencia2.IdParentesco);
                        nuevo.Urgencia = true;
                        nuevo.ChangeTracker.State = ObjectState.Added;
                        alumno.AlumnoFamiliares.Add(nuevo);

                        this.view.pnlDatosRecuperadosUrgencia2.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        if (alumno.Urgencia2.LegajoFamiliar != fam.LegajoFamiliar)
                        {
                            int i = 0;
                            Guid idFamiliar = fam.LegajoFamiliar;
                            foreach (var item in alumno.AlumnoFamiliares)
                            {
                                if (item.LegajoFamiliar != idFamiliar)
                                    i++;
                                else
                                    break;
                            }
                            this.alumno.AlumnoFamiliares.RemoveAt(i);

                            alumno.Urgencia2 = fam;
                            AlumnoFamiliar nuevo = new AlumnoFamiliar();
                            nuevo.LegajoAlumno = alumno.LegajoAlumno;
                            nuevo.LegajoFamiliar = alumno.Urgencia2.LegajoFamiliar;
                            nuevo.IdParentesco = new Guid(alumno.Urgencia2.IdParentesco);
                            nuevo.Urgencia = true;
                            nuevo.ChangeTracker.State = ObjectState.Added;
                            alumno.AlumnoFamiliares.Add(nuevo);

                        }
                    }
                    break;



            }

        }

        internal void CompletarNombresDNI()
        {

            if (String.IsNullOrWhiteSpace(this.alumno.DniAlumno))
            {
                this.alumno.DniAlumno = this.alumnoSinModificaciones.DniAlumno;
            }

            if (String.IsNullOrWhiteSpace(this.alumno.ApellidoAlumno))
            {
                this.alumno.ApellidoAlumno = this.alumnoSinModificaciones.ApellidoAlumno;
            }

            if (String.IsNullOrWhiteSpace(this.alumno.NombreAlumno))
            {
                this.alumno.NombreAlumno = this.alumnoSinModificaciones.NombreAlumno;
            }


        }




        private bool Validaciones()
        {

            if (String.IsNullOrWhiteSpace(alumno.DniAlumno))
            {
                if (this.alumnoSinModificaciones != null)
                    this.CompletarNombresDNI();


                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'DNI del Alumno' es obligatorio");
                nueva.ShowDialog();
                return false;
            }
            else
            {

                if (alumno.DniAlumno.Length < 8)
                {
                    if (this.alumnoSinModificaciones != null)
                        this.CompletarNombresDNI();

                    VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El DNI debe tener 8 dígitos");
                    nueva.ShowDialog();
                    return false;

                }
                else
                {

                    if (new AlumnoLogica().ExisteDNI(alumno.DniAlumno, alumno.LegajoAlumno))
                    {
                        if (this.alumnoSinModificaciones != null)
                            this.CompletarNombresDNI();

                        VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El alumno que desea ingresar ya existe en el sistema");
                        nueva.ShowDialog();
                        return false;

                    }

                }
            }

            if (String.IsNullOrWhiteSpace(alumno.NombreAlumno))
            {
                if (this.alumnoSinModificaciones != null)
                    this.CompletarNombresDNI();

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'Nombre' es obligatorio");
                nueva.ShowDialog();
                return false;
            }

            if (String.IsNullOrWhiteSpace(alumno.ApellidoAlumno))
            {
                if (this.alumnoSinModificaciones != null)
                    this.CompletarNombresDNI();

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'Apellido' es obligatorio");
                nueva.ShowDialog();
                return false;
            }

            if (String.IsNullOrWhiteSpace(alumno.DireccionAlumno))
            {
                if (this.alumnoSinModificaciones != null)
                    this.alumno.DireccionAlumno = this.alumnoSinModificaciones.DireccionAlumno;

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'Domicilio' es obligatorio");
                nueva.ShowDialog();
                return false;
            }

            if (String.IsNullOrWhiteSpace(alumno.LocalidadAlumno))
            {
                if (this.alumnoSinModificaciones != null)
                    this.alumno.LocalidadAlumno = this.alumnoSinModificaciones.LocalidadAlumno;

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'Localidad' es obligatorio");
                nueva.ShowDialog();
                return false;
            }

            if (this.alumno.FechaNacimiento.ToShortDateString() == "01/01/0001")
            {
                if (this.alumnoSinModificaciones != null)
                    this.alumno.FechaNacimiento = this.alumnoSinModificaciones.FechaNacimiento;

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "El campo 'Fecha de Nacimiento' es obligatorio");
                nueva.ShowDialog();
                return false;
            }


            if (this.alumno.FechaNacimiento >= DateTime.Now)
            {
                if (this.alumnoSinModificaciones != null)
                    this.alumno.FechaNacimiento = this.alumnoSinModificaciones.FechaNacimiento;

                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "La Fecha de Nacimiento ingresada es incorrecta");
                nueva.ShowDialog();
                return false;
            }

             TimeSpan edad = DateTime.Now.Subtract(this.alumno.FechaNacimiento);

             if (edad.Days > 2190 || edad.Days <= 365) // Menor a 6 años y mayor a 1 año
             {

                 if (this.alumnoSinModificaciones != null)
                     this.alumno.FechaNacimiento = this.alumnoSinModificaciones.FechaNacimiento;

                 VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "La Fecha de Nacimiento ingresada es incorrecta");
                 nueva.ShowDialog();
                 return false;

             }


            if (this.alumno.AlumnoVidaFamiliar.RelacionPadres == "Otra" && String.IsNullOrWhiteSpace(this.view.descripcionSituacionPadres.Texto) )
            {
                
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe describir cuál es la 'Situacion de los Padres'");
                nueva.ShowDialog();
                return false;
            }

            if (this.view.recibeMedicamento.ValorSeleccionado == true && String.IsNullOrWhiteSpace(this.view.txtRecibeMedicamentoaDiario.Texto))
            {
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe decir cuál es el Medicamento que el alumno recibe a diario");
                nueva.ShowDialog();
                return false;
            }

            if (this.view.controlaEsfinteresSiNo.ValorSeleccionado == true && String.IsNullOrWhiteSpace(this.view.edadEsfinteres.Texto))
            {
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe decir cuál es edad en la que el alumno controló esfínteres");
                nueva.ShowDialog();
                return false;
            }

            if (alumno.MadreTutora.LegajoFamiliar == Guid.Empty && alumno.PadreTutor.LegajoFamiliar == Guid.Empty)
            {
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe cargar los datos de la madre/tutora o del padre/tutor");
                nueva.ShowDialog();
                return false;
            }

            if (this.alumno.AlumnoVidaFamiliar.RelacionPadres == "Otra" && String.IsNullOrWhiteSpace(this.view.descripcionSituacionPadres.Texto))
            {
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar cuál es la situación de los padres");
                nueva.ShowDialog();
                return false;
            }

            if (this.view.tuvoDificultadPartoSiNo.ValorSeleccionado == true)
            {
                if (String.IsNullOrWhiteSpace(this.view.txtCualDificultadParto.Text) || String.IsNullOrWhiteSpace(this.view.periodoDificultadesEmbarazo.Texto))
                {
                    VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar cuál fue la dificultad del parto y en qué período sucedió");
                    nueva.ShowDialog();
                    return false;
                }
            }


            if (this.alumno.AlumnoNacimiento.Parto != null  && this.alumno.AlumnoNacimiento.Parto != "A término" && String.IsNullOrWhiteSpace(this.alumno.AlumnoNacimiento.CausasParto))
            {
                VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar una causa por la cual el parto no fue 'A término'");
                nueva.ShowDialog();
                return false;
            }

            if (this.alumno.AlumnoAlimentacion.RechazaAlimentos == true)
            {
                if (String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.AlimentosRechazados) || String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.ActitudNoQuiereComer))
                {
                    VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar qué alimentos rechaza el niño y la actitud que se toma cuando no quiere comer");
                    nueva.ShowDialog();
                    return false;
                }

            }


            if (this.alumno.AlumnoAlimentacion.UsaActualmenteMamadera == true)
            {
                if (String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.MomentosMamadera) )
                {
                    VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar los momentos del uso de la mamadera");
                    nueva.ShowDialog();
                    return false;
                }

                if (this.alumno.AlumnoAlimentacion.AbandonoMamadera == true)
                {
                    if (String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.TipoAbandonoMamadera) || String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.CuandoAbandonoMamadera))
                    {
                        VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar los datos referidos al abandono de la mamadera");
                        nueva.ShowDialog();
                        return false;

                    }
                }

            }

            if (this.alumno.AlumnoAlimentacion.UsaActualmenteChupete  == true)
            {
                if (String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.MomentosChupete))
                {
                    VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar los momentos del uso de la chupete");
                    nueva.ShowDialog();
                    return false;
                }

                if (this.alumno.AlumnoAlimentacion.AbandonoChupete == true)
                {
                    if (String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.TipoAbandonoChupete) || String.IsNullOrWhiteSpace(this.alumno.AlumnoAlimentacion.CuandoAbandonoChupete))
                    {
                        VentanaAviso nueva = new VentanaAviso(true, "Se ha producido un error", "Debe especificar los datos referidos al abandono de la chupete");
                        nueva.ShowDialog();
                        return false;

                    }
                }

            }





            return true;
        }


        private void ValidacionesDeConsistencia()
        {

            if (this.view.controlaEsfinteresSiNo.ValorSeleccionado == false && !String.IsNullOrEmpty(this.view.edadEsfinteres.Texto))
            {
                this.alumno.AlumnoSalud.EdadControlEsfinteres = null;

            }

            if (this.view.recibeMedicamento.ValorSeleccionado == false && !String.IsNullOrEmpty(this.view.txtRecibeMedicamentoaDiario.Texto))
            {
                this.alumno.AlumnoSalud.DetalleMedicamentos = null;
            }

            if (this.view.tieneEspacioJuegoSiNo.ValorSeleccionado == false && !String.IsNullOrEmpty(this.view.txtEspacioJuego.Text))
            {
                this.alumno.EspacioJuego = null;
            }

            if (this.view.tieneHermanosSiNo.ValorSeleccionado == false && this.alumno.HermanosAlumno.Count > 0)
            {
                this.alumno.HermanosAlumno.Clear();
            }

            if (this.alumno.AlumnoVidaFamiliar.RelacionPadres != "Otra")
            {
                this.alumno.AlumnoVidaFamiliar.OtraRelacionPadres = null;
            }

            if (this.alumno.AlumnoHabitos.DespiertaQueHace == "Otra reacción")
            {
                this.alumno.AlumnoHabitos.DespiertaQueHace = this.view.otraReaccion.Texto;
            }


            if (this.view.tuvoDificultadPartoSiNo.ValorSeleccionado == false)
            {
                alumno.AlumnoNacimiento.DescripcionDificultad = alumno.AlumnoNacimiento.PeriodoDificultad = null;
            }

            if (this.alumno.AlumnoNacimiento.Parto == "A término")
            {
                this.alumno.AlumnoNacimiento.CausasParto = null;
            }

            if (Alumno.AlumnoAlimentacion.RechazaAlimentos == false)
            {
                this.alumno.AlumnoAlimentacion.AlimentosRechazados = this.alumno.AlumnoAlimentacion.ActitudNoQuiereComer = null;          
               
            }


            if (Alumno.AlumnoAlimentacion.AbandonoMamadera == false)
            {

                this.alumno.AlumnoAlimentacion.MomentosMamadera = this.alumno.AlumnoAlimentacion.TipoAbandonoMamadera = this.alumno.AlumnoAlimentacion.CuandoAbandonoMamadera = null;

            }

            if (Alumno.AlumnoAlimentacion.AbandonoMamadera == true)  // No se usa el Else porque el campo puede tomar valor True, False o Null
            {
                if (this.alumno.AlumnoAlimentacion.UsaActualmenteMamadera == false)
                {
                    this.alumno.AlumnoAlimentacion.TipoAbandonoMamadera = this.alumno.AlumnoAlimentacion.CuandoAbandonoMamadera = null;

                }

            }

            if (Alumno.AlumnoAlimentacion.AbandonoChupete == false)
            {

                this.alumno.AlumnoAlimentacion.MomentosChupete = this.alumno.AlumnoAlimentacion.TipoAbandonoChupete = this.alumno.AlumnoAlimentacion.CuandoAbandonoChupete = null;

            }

            if (Alumno.AlumnoAlimentacion.AbandonoChupete == true)  // No se usa el Else porque el campo puede tomar valor True, False o Null
            {
                if (this.alumno.AlumnoAlimentacion.UsaActualmenteChupete == false)
                {
                    this.alumno.AlumnoAlimentacion.TipoAbandonoChupete = this.alumno.AlumnoAlimentacion.CuandoAbandonoChupete = null;

                }

            }



        }





        internal void CargarListas()
        {
            ListaParentescos = new ParentescoLogica().GetAllParentescosView();

            ListaTiposSanguineos = new List<ViewEntity>();
            ListaTiposSanguineos.Add(new ViewEntity("Grupo A Factor RH +"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo A Factor RH -"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo B Factor RH +"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo B Factor RH -"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo AB Factor RH +"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo AB Factor RH -"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo O Factor RH +"));
            ListaTiposSanguineos.Add(new ViewEntity("Grupo O Factor RH -"));

            ListaSituacionPadres = new List<ViewEntity>();
            ListaSituacionPadres.Add(new ViewEntity("Juntos"));
            ListaSituacionPadres.Add(new ViewEntity("Separados"));
            ListaSituacionPadres.Add(new ViewEntity("Divorciados"));
            ListaSituacionPadres.Add(new ViewEntity("Otra"));

            ListaZonaVivienda = new List<ViewEntity>();
            ListaZonaVivienda.Add(new ViewEntity("Urbana"));
            ListaZonaVivienda.Add(new ViewEntity("Rural"));

            ListaTipoParto = new List<ViewEntity>();
            ListaTipoParto.Add(new ViewEntity("A término"));
            ListaTipoParto.Add(new ViewEntity("Prematuro"));
            ListaTipoParto.Add(new ViewEntity("Prolongado"));
            ListaTipoParto.Add(new ViewEntity("Inducido"));
            ListaTipoParto.Add(new ViewEntity("Con fórceps"));
            ListaTipoParto.Add(new ViewEntity("Por cesárea"));

            ListaTipoLactancia = new List<ViewEntity>();
            ListaTipoLactancia.Add(new ViewEntity("Natural"));
            ListaTipoLactancia.Add(new ViewEntity("Artificial"));
            ListaTipoLactancia.Add(new ViewEntity("Mixta"));

            ListaTipoDestete = new List<ViewEntity>();
            ListaTipoDestete.Add(new ViewEntity("Espontáneo"));
            ListaTipoDestete.Add(new ViewEntity("Progresivo"));
            ListaTipoDestete.Add(new ViewEntity("Impuesto"));
            ListaTipoDestete.Add(new ViewEntity("Tardío"));

            ListaTipoAbandonoMamadera = new List<ViewEntity>();
            ListaTipoAbandonoMamadera.Add(new ViewEntity("Espontáneo"));
            ListaTipoAbandonoMamadera.Add(new ViewEntity("Progresivo"));
            ListaTipoAbandonoMamadera.Add(new ViewEntity("Impuesto"));
            ListaTipoAbandonoMamadera.Add(new ViewEntity("Brusco"));

            ListaTipoAbandonoChupete = new List<ViewEntity>();
            ListaTipoAbandonoChupete.Add(new ViewEntity("Espontaneo"));
            ListaTipoAbandonoChupete.Add(new ViewEntity("Progresivo"));
            ListaTipoAbandonoChupete.Add(new ViewEntity("Impuesto"));
            ListaTipoAbandonoChupete.Add(new ViewEntity("Brusco"));

            ListaSiSeDespierta = new List<ViewEntity>();
            ListaSiSeDespierta.Add(new ViewEntity("Llora"));
            ListaSiSeDespierta.Add(new ViewEntity("Llama a la Madre"));
            ListaSiSeDespierta.Add(new ViewEntity("Otra reacción"));

            ListaTipoDespertar = new List<ViewEntity>();
            ListaTipoDespertar.Add(new ViewEntity("Alegre"));
            ListaTipoDespertar.Add(new ViewEntity("Malhumorado"));

            ListaTipoPronunciacion = new List<ViewEntity>();
            ListaTipoPronunciacion.Add(new ViewEntity("Buena"));
            ListaTipoPronunciacion.Add(new ViewEntity("Regular"));
            ListaTipoPronunciacion.Add(new ViewEntity("Mala"));

            ListaTipoJuego = new List<ViewEntity>();
            ListaTipoJuego.Add(new ViewEntity("Solo"));
            ListaTipoJuego.Add(new ViewEntity("Acompañado"));
            
        }



    }
}
